package principal;

import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import visualisationRadar.VisualisationRadar;

/**
 * Fabrique de fichiers. Cette classe génére des fichiers en fonction du lieu,
 * de la ou les dates et du type de données. Elle dispose en outre de méthodes
 * statiques facilitant la conversion des extensions sous forme de chaines en
 * entier (et inversement).
 * 
 * @author laurent & kevin
 * 
 */
public class FileFactory {

	/**
	 * Méthode statique traduisant un type sous forme d'entier en extension sous
	 * forme de chaine.
	 * 
	 * @param type
	 *            Entier définissant le type d'image (RR, QUALITE, etc )
	 * @return Chaine correspondant à l'extension du fichier d'une image.
	 */
	public static String extensionIntToString(int type) {
		switch (type) {
		case VisualisationRadar.RR:
			return "RR";
		case VisualisationRadar.RRcumul:
			return "RRcumul";
		case VisualisationRadar.QUALITE:
			return "QUALITE";
		case VisualisationRadar.QUALITEcumul:
			return "QUALITEcumul";
		default:
			System.err.println("Type n° " + type + " inconnu.");
			return null;
		}
	}

	/**
	 * Méthode statique traduisant une extension (chaine) en type (entier).
	 * Methode inverse de la précédente.
	 * 
	 * @param type
	 *            Extension sous forme de chaine
	 * @return Un entier codant pour le type d'image
	 */
	public static int extensionStringToInt(String type) {
		Type extension = null;
		try {
			extension = Type.valueOf(type);
		} catch (IllegalArgumentException e) {
//			System.out.println("Fichier ." + type + " non supportée");
			return 0;
		}
		switch (extension) {
		case RR:
			return VisualisationRadar.RR;
		case RRcumul:
			return VisualisationRadar.RRcumul;
		case QUALITE:
			return VisualisationRadar.QUALITE;
		case QUALITEcumul:
			return VisualisationRadar.QUALITEcumul;
		default:
			return 0;
		}
	}

	public static String buildFileString(String radar, Date date, int type) {
		String repDonnees = null;
		String dateStr = dateToFormatFichier(date);
		if (type == VisualisationRadar.RR || type == VisualisationRadar.RRcumul)
			repDonnees = VisualisationRadar.repertoireDonneesRR;
		else
			repDonnees = VisualisationRadar.repertoireDonneesQualite;
		String nomFichier = repDonnees + radar + "_" + dateStr + "."
				+ extensionIntToString(type);
		return nomFichier;
	}

	public static String buildFileString(String radar, Date dateDebut,
			Date dateFin, int type) {
		String dateDebutStr = "_" + dateToFormatFichier(dateDebut) + "_";
		String nomFichier = buildFileString(radar, dateFin, type).replace("_",
				dateDebutStr);
		return nomFichier;
	}

	/**
	 * Méthode statique fabriquant un fichier. Le fichier généré correspond à un
	 * cumul 5min.
	 * 
	 * @param radar
	 *            Nom du radar
	 * @param date
	 *            Date du fichier cumul
	 * @param type
	 *            Type de fichier
	 * @return Un fichier.
	 */
	public static File getFileFrom(String radar, Date date, int type) {
		return new File(buildFileString(radar, date, type));
	}

	/**
	 * Méthode statique fabriquant un fichier. Le fichier généré correspond à un
	 * cumul > à 5min.
	 * 
	 * @param radar
	 *            Nom du radar
	 * @param dateDebut
	 *            Date de début du cumul
	 * @param dateFin
	 *            Date de fin du cumul
	 * @param type
	 *            Type de fichier
	 * @return Un fichier
	 */
	public static File getFileFrom(String radar, Date dateDebut, Date dateFin,
			int type) {
		return new File(buildFileString(radar, dateDebut, dateFin, type));
	}

	/**
	 * Détermine le type d'image en fonction du nom du fichier.
	 * 
	 * @param file
	 *            Fichier à traiter
	 * @return Entier codant le type d'image
	 */
	public static int 
	getTypeFromFile(File file) {
		String nomFichier = file.getName();
		return extensionStringToInt(nomFichier.substring(nomFichier
				.indexOf(".") + 1));
	}

	public static Date changeDate(Date date, int field, int amount) {
		Calendar calendar = GregorianCalendar.getInstance();
		calendar.setTime(date);
		calendar.add(field, amount);
		return calendar.getTime();
	}

	public static GregorianCalendar getCalendar() {
		return calendar;
	}

	public static String dateToFormatFichier(Date date) {
		return dateFormatFichier.format(date);
	}

	public static String dateToFormatHumain(Date date) {
		return dateFormatHumain.format(date);
	}

	public static Date stringToDate(String str) {
		try {
			return dateFormatFichier.parse(str);
		} catch (ParseException e) {
			System.err.println("La date n'est pas au bon format.");
			return null;
		}
	}

	public static String getRadar(File fichier) {
		return fichier.getName().substring(0, fichier.getName().indexOf("_"));
	}

	public static Date getDateDebut(File fichier) {
		String[] tabString = fichier.getName().split("_");
		if (tabString.length <= 2)
			return null;
		else {
			String dateDebutStr = tabString[1];
			return stringToDate(dateDebutStr);
		}
	}

	public static Date getDateFin(File fichier) {
		String[] tabString = fichier.getName().split("_");
		String[] tabString2;
		String dateFinStr;
		if (tabString.length == 2) {
			tabString2 = tabString[1].split("\\.");

		} else {
			tabString2 = tabString[2].split("\\.");
		}
		dateFinStr = tabString2[0];
		return stringToDate(dateFinStr);
	}

	public static File[] buildListeFiles(String radar, Date date, int type ,int profondeur) {
		int nbFichiers = profondeur / 5 ;
		File [] tabFile = new File[nbFichiers] ;
		for (int i=0 ; i < tabFile.length ; i++) {
			tabFile[i] = getFileFrom(radar, date, type) ;
			date = changeDate(date, Calendar.MINUTE, -5) ;
		}
		
		return tabFile;
	}
	/*
	 * Vérifie l'existence des fichiers. Retourne vrai si tous les fichiers existent.
	 */
	public static boolean checkFiles(File [] tabFile) {
		for (int i= 0; i< tabFile.length; i++) {
			if (!tabFile[i].exists()) {
				System.err.println("Fichier " + tabFile[i] + " manquant.");
				return false ;
			}
		}
		return true ;
	}
	
	
	public enum Type {
		RR, RRcumul, QUALITE, QUALITEcumul
	};

	private static final SimpleDateFormat dateFormatFichier = new SimpleDateFormat(
			"yyyyMMddHHmm");
	private static final SimpleDateFormat dateFormatHumain = new SimpleDateFormat(
			"EEEE dd MMMM yyyy 'à' HH'H'mm");
	private static GregorianCalendar calendar;
	
}
